1. Technical Field
The present invention relates generally to an improved data processing system and, in particular, to a method and system for improving performance of the processor in a data processing system. Still more particularly, the present invention relates to a method, apparatus, and computer instructions for improving branch predictions by autonomically counting branch instructions executed in a processor.
2. Description of Related Art
In a pipelined processor system, instructions are often prefetched from memory to keep the pipeline busy. However, a branch instruction may cause a pipeline to stall. A branch instruction is an instruction that loads a new value in the program counter. As a result, the processor fetches and executes the instruction at this new address, instead of the instruction at the location that follows the branch instruction in sequential address order. A branch instruction may be conditional or unconditional. A conditional branch instruction causes an instruction to branch or jump to another location of code if a specified condition is satisfied. If the condition is not satisfied, the next instruction in sequential order is fetched and executed.
Branch instructions often cause the pipeline to stall because the branch condition may depend on the result of preceding instruction. The decision to branch cannot be made until the execution of that instruction has been completed. Therefore, a technique known as branch prediction is used to predict whether or not a particular branch will be taken. A speculative execution is performed to take advantage of branch prediction by executing the instruction before the processor is certain that they are in the correct execution path. Thus, if a branch is taken more than 90 percent of the time, it is predicted to be taken and executed by the processor prior to reaching the instruction.
Conventionally, branch prediction may be performed in two ways. One way is known as static branch prediction. This approach is performed by the compiler at compile time, which looks at the OP code word of the instruction to indicate whether this branch should be predicted as taken or not taken. The prediction result is the same every time a given branch instruction is encountered. Another approach of branch prediction is known as dynamic branch prediction, which is performed at run time, by keeping track of the result of the branch decision the last time that instruction was executed and assuming that the decision is likely to be the same this time. The prediction result may be different each time the instruction is encountered.
In order to perform dynamic branch prediction, several techniques have been introduced in the prior art. One of which is a branch prediction buffer, which utilizes a buffer or cache indexed by lower portion of the address of the branch instruction to indicate whether the branch was recently taken or not. However, this technique requires a special cache that would be accessed during fetching and flushed after the predictions are complete.
Another existing technique for performing dynamic branch prediction uses a branch target buffer, which is similar to a cache, except the value in the cache includes the address of the next instruction instead of the contents of the memory location. Also, the instruction itself may be stored instead of the address. This approach is known as branch folding. However, none of the currently existing techniques provide a solution for branch prediction at the instruction level, where detailed branch statistics are collected per branch instruction. In addition, none of the currently existing techniques provides a running history of branch prediction by associating branch statistic fields with branch instructions, so that better branch predictions may be performed by storing branch prediction values associated with each branch instruction in a dedicated memory location.
Therefore, it would be advantageous to have an improved method, apparatus and computer instructions for counting branch instructions to improve branch prediction, so that localized branch prediction may be performed at the instruction level during code execution and branch statistics may be collected later on to optimize performance of the system.